package com.prs.crm.action.oa;

import java.util.Date;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.courser.struts.BaseAction;

import com.prs.crm.domain.archives.ArchivesManager;
import com.prs.crm.domain.archives.ArchivesType;
import com.prs.crm.domain.oa.Announcement;
import com.prs.crm.domain.oa.AnnouncementCollect;
import com.prs.crm.domain.oa.AnnouncementReceive;
import com.prs.crm.domain.oa.Archives;
import com.prs.crm.domain.oa.ArchivesCategory;
import com.prs.crm.domain.oa.News;
import com.prs.crm.domain.oa.NewsCollect;
import com.prs.crm.domain.oa.NewsReceive;
import com.prs.crm.domain.oa.Notice;
import com.prs.crm.domain.oa.NoticeAccept;
import com.prs.crm.domain.oa.NoticeCollect;
import com.prs.crm.domain.oa.PictureNews;
import com.prs.crm.domain.oa.PictureNewsCollect;
import com.prs.crm.domain.oa.PictureNewsReceive;
import com.prs.crm.service.archives.ArchivesManagerService;
import com.prs.crm.service.archives.ArchivesTypeService;
import com.prs.crm.service.oa.AnnouncementCollectService;
import com.prs.crm.service.oa.AnnouncementReceiveService;
import com.prs.crm.service.oa.AnnouncementService;
import com.prs.crm.service.oa.ArchivesCategoryService;
import com.prs.crm.service.oa.ArchivesService;
import com.prs.crm.service.oa.NewsCollectService;
import com.prs.crm.service.oa.NewsReceiveService;
import com.prs.crm.service.oa.NewsService;
import com.prs.crm.service.oa.NoticeAcceptService;
import com.prs.crm.service.oa.NoticeCollectService;
import com.prs.crm.service.oa.NoticeService;
import com.prs.crm.service.oa.PictureNewsCollectService;
import com.prs.crm.service.oa.PictureNewsReceiveService;
import com.prs.crm.service.oa.PictureNewsService;

public class ArchivesCategoryAction extends BaseAction{
	private static final long serialVersionUID = 1L;
	private ArchivesManager archivesManager;
	private ArchivesManagerService archivesManagerService;
	private ArchivesType archivesType;
	private ArchivesTypeService archivesTypeService;
	private Integer id;  //档案类目id
	private Integer[] newsIds; 
	private Integer[] receiveIds;
	private Integer[] collectIds;
	private NewsCollect newsCollect;
	private NewsCollectService newsCollectService;
	private News news;
	private NewsService newsService;
	private NewsReceive newsReceive;
	private NewsReceiveService newsReceiveService;
	private PictureNews pictureNews;
	private PictureNewsService pictureNewsService;
	private PictureNewsReceive pictureNewsReceive;
	private PictureNewsReceiveService pictureNewsReceiveService;
	private Integer[] pictureIds;
	private PictureNewsCollect pictureNewsCollect;
	private PictureNewsCollectService pictureNewsCollectService;
	private Announcement announcement;
	private AnnouncementService announcementService;
	private Integer[] announcementIds;
	private AnnouncementReceive announcementReceive;
	private AnnouncementReceiveService announcementReceiveService;
	private AnnouncementCollect announcementCollect;
	private AnnouncementCollectService announcementCollectService;
	private Notice notice;
	private NoticeService noticeService;
	private Integer[] noticeIds;
	private NoticeAccept noticeAccept;
	private NoticeAcceptService noticeAcceptService;
	private NoticeCollect noticeCollect;
	private NoticeCollectService noticeCollectService;
	
	@Action(value = "saveCategory", results = {
			@Result(name = "success", type = "redirect", location = "listHaveNews"),
			@Result(name = "error", type = "chain", location = "listHaveNews")})
	public String saveCategory() {
		if(newsIds!=null){
			this.news=this.newsService.get(newsIds[0]);
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(news.getTitle());
		category.setDegree(news.getDegree());
		category.setSendTime(news.getRecordTime());
		category.setSendPerson(news.getRecorder());
		category.setReceivePerson(news.getReceive());
		category.setContent(news.getContent());
		category.setState(0);
		if (news.getAttach()!=null) {
			category.setAttach(news.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已发信息中就看不到了
		news.setOabox(2);
		this.newsService.submit(news);
		return SUCCESS;
	}
	@Action(value = "saveCategoryReceive", results = {
			@Result(name = "success", type = "redirect", location = "listReceiveNews"),
			@Result(name = "error", type = "chain", location = "listReceiveNews")})
	public String saveCategoryReceive() {
		if(this.receiveIds!=null){
			this.newsReceive=this.newsReceiveService.get(receiveIds[0]);
		}
//		this.news=this.newsReceive.getNews();
		
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(newsReceive.getTitle());
		category.setDegree(newsReceive.getDegree());
		category.setSendTime(newsReceive.getRecordTime());
		category.setSendPerson(newsReceive.getRecorder());
		category.setReceivePerson(newsReceive.getReceivePerson().getResume().getName());
		category.setContent(newsReceive.getContent());
		category.setState(0);
		if (newsReceive.getAttach()!=null) {
			category.setAttach(newsReceive.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//删除
		newsReceive.setOabox(2);
		this.getNewsReceiveService().submit(newsReceive);
		return SUCCESS;
	}
	@Action(value = "saveCategory2", results = {
			@Result(name = "success", type = "redirect", location = "listCollectNews"),
			@Result(name = "error", type = "chain", location = "listCollectNews") })
	public String saveCategory2() {
		if(this.collectIds!=null){
			this.newsCollect=this.newsCollectService.get(collectIds[0]);
			this.news=newsCollect.getNews();
			this.newsReceive=newsCollect.getNewsReceive();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		if (news!=null) {
			category.setArchivesName(news.getTitle());
			category.setDegree(news.getDegree());
			category.setSendTime(news.getRecordTime());
			category.setSendPerson(news.getRecorder());
			category.setReceivePerson(news.getReceive());
			category.setContent(news.getContent());
			category.setState(0);
			if (news.getAttach()!=null) {
				category.setAttach(news.getAttach());
			}
		}
		if (newsReceive!=null) {
			category.setArchivesName(newsReceive.getTitle());
			category.setDegree(newsReceive.getDegree());
			category.setSendTime(newsReceive.getRecordTime());
			category.setSendPerson(newsReceive.getRecorder());
			category.setReceivePerson(newsReceive.getReceivePerson().getResume().getName());
			category.setContent(newsReceive.getContent());
			category.setState(0);
			if (newsReceive.getAttach()!=null) {
				category.setAttach(newsReceive.getAttach());
			}
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//删除
		this.newsCollectService.remove(this.newsCollect);
		return SUCCESS;
	}
	@Action(value = "saveCategoryByPicture", results = {
			@Result(name = "success", type = "redirect", location = "listPictureNews"),
			@Result(name = "error", type = "chain", location = "listPictureNews")})
	public String saveCategoryByPicture() {
		if(this.pictureIds!=null){
			this.pictureNews=this.pictureNewsService.get(pictureIds[0]);
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(pictureNews.getTitle());
		category.setDegree(pictureNews.getDegree());
		category.setSendTime(pictureNews.getRecordTime());
		category.setSendPerson(pictureNews.getRecorder());
		category.setReceivePerson(pictureNews.getReceive());
		category.setContent(pictureNews.getContent());
		category.setState(0);
		if (pictureNews.getAttach()!=null) {
			category.setAttach(pictureNews.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已发信息中就看不到了
		pictureNews.setOabox(2);
		this.pictureNewsService.submit(pictureNews);
		if (pictureNews.getOabox()==2) {
			PictureNewsCollect coll=this.getPictureNewsCollectService().getPictureNewsCollectByPicture(pictureNews);
			if (coll!=null) {
				this.pictureNewsCollectService.remove(coll);
			}
		}
		return SUCCESS;
	}
	@Action(value = "saveCategoryByPictureReceive", results = {
			@Result(name = "success", type = "redirect", location = "listPictureNewsReceive"),
			@Result(name = "error", type = "chain", location = "listPictureNewsReceive")})
	public String saveCategoryByPictureReceive() {
		if(this.receiveIds!=null){
			this.pictureNewsReceive=this.getPictureNewsReceiveService().get(receiveIds[0]);
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(pictureNewsReceive.getTitle());
		category.setDegree(pictureNewsReceive.getDegree());
		category.setSendTime(pictureNewsReceive.getRecordTime());
		category.setSendPerson(pictureNewsReceive.getRecorder());
		category.setReceivePerson(pictureNewsReceive.getReceivePerson().getResume().getName());
		category.setContent(pictureNewsReceive.getContent());
		category.setState(0);
		if (pictureNewsReceive.getAttach()!=null) {
			category.setAttach(pictureNewsReceive.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已发信息中就看不到了
		pictureNewsReceive.setOabox(2);
		this.getPictureNewsReceiveService().submit(pictureNewsReceive);
		if (pictureNewsReceive.getOabox()==2) {
			PictureNewsCollect coll=this.getPictureNewsCollectService().getPictureNewsCollectByPictureReceive(pictureNewsReceive);
			if (coll!=null) {
				this.pictureNewsCollectService.remove(coll);
			}
		}
		return SUCCESS;
	}
	@Action(value = "saveCategoryByPictureCollect", results = {
			@Result(name = "success", type = "redirect", location = "listPictureNewsCollect"),
			@Result(name = "error", type = "chain", location = "listPictureNewsCollect")})
	public String saveCategoryByPictureCollect() {
		if(this.collectIds!=null){
			this.pictureNewsCollect=this.pictureNewsCollectService.get(collectIds[0]);
			this.pictureNews=pictureNewsCollect.getPictureNews();
			this.pictureNewsReceive=pictureNewsCollect.getPictureNewsReceive();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		if (pictureNews!=null) {
			category.setArchivesName(pictureNews.getTitle());
			category.setDegree(pictureNews.getDegree());
			category.setSendTime(pictureNews.getRecordTime());
			category.setSendPerson(pictureNews.getRecorder());
			category.setReceivePerson(pictureNews.getReceive());
			category.setContent(pictureNews.getContent());
			category.setState(0);
			if (pictureNews.getAttach()!=null) {
				category.setAttach(pictureNews.getAttach());
			}
		}
		if (pictureNewsReceive!=null) {
			category.setArchivesName(pictureNewsReceive.getTitle());
			category.setDegree(pictureNewsReceive.getDegree());
			category.setSendTime(pictureNewsReceive.getRecordTime());
			category.setSendPerson(pictureNewsReceive.getRecorder());
			category.setReceivePerson(pictureNewsReceive.getReceivePerson().getResume().getName());
			category.setContent(pictureNewsReceive.getContent());
			category.setState(0);
			if (pictureNewsReceive.getAttach()!=null) {
				category.setAttach(pictureNewsReceive.getAttach());
			}
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息看不到了
		this.pictureNewsCollectService.remove(this.pictureNewsCollect);
		return SUCCESS;
	}
	@Action(value = "saveCategoryAnnouncement", results = {
			@Result(name = "success", type = "redirect", location = "listAnnouncement"),
			@Result(name = "error", type = "chain", location = "listAnnouncement")})
	public String saveCategoryAnnouncement() {
		if(this.announcementIds!=null){
			this.announcement=this.announcementService.get(announcementIds[0]);
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(announcement.getTitle());
		category.setDegree(announcement.getDegree());
		category.setSendTime(announcement.getRecordTime());
		category.setSendPerson(announcement.getRecorder());
		category.setReceivePerson(announcement.getReceive());
		category.setContent(announcement.getContent());
		category.setState(0);
		if (announcement.getAttach()!=null) {
			category.setAttach(announcement.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已发信息中就看不到了
		announcement.setOabox(2);
		this.announcementService.submit(announcement);
		return SUCCESS;
	}
	@Action(value = "saveCategoryAnnouncementReceive", results = {
			@Result(name = "success", type = "redirect", location = "listAnnouncementReceive"),
			@Result(name = "error", type = "chain", location = "listAnnouncementReceive")})
	public String saveCategoryAnnouncementReceive() {
		if(this.receiveIds!=null){
			this.announcementReceive=this.announcementReceiveService.get(receiveIds[0]);
//			this.announcement=announcementReceive.getAnnouncement();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(announcementReceive.getTitle());
		category.setDegree(announcementReceive.getDegree());
		category.setSendTime(announcementReceive.getRecordTime());
		category.setSendPerson(announcementReceive.getRecorder());
		category.setReceivePerson(announcementReceive.getReceivePerson().getResume().getName());
		category.setContent(announcementReceive.getContent());
		category.setState(0);
		if (announcementReceive.getAttach()!=null) {
			category.setAttach(announcementReceive.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已收信息中就看不到了
		announcementReceive.setOabox(2);
		this.announcementReceiveService.submit(announcementReceive);
		return SUCCESS;
	}
	
	@Action(value = "saveCategoryAnnouncementCollect", results = {
			@Result(name = "success", type = "redirect", location = "listAnnouncementCollect"),
			@Result(name = "error", type = "chain", location = "listAnnouncementCollect")})
	public String saveCategoryAnnouncementCollect() {
		if(this.collectIds!=null){
			this.announcementCollect=this.announcementCollectService.get(collectIds[0]);
			this.announcement=announcementCollect.getAnnouncement();
			this.announcementReceive=announcementCollect.getAnnouncementReceive();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		if (announcement!=null) {
			category.setArchivesName(announcement.getTitle());
			category.setDegree(announcement.getDegree());
			category.setSendTime(announcement.getRecordTime());
			category.setSendPerson(announcement.getRecorder());
			category.setReceivePerson(announcement.getReceive());
			category.setContent(announcement.getContent());
			category.setState(0);
			if (announcement.getAttach()!=null) {
				category.setAttach(announcement.getAttach());
			}
		}
		if (announcementReceive!=null) {
			category.setArchivesName(announcementReceive.getTitle());
			category.setDegree(announcementReceive.getDegree());
			category.setSendTime(announcementReceive.getRecordTime());
			category.setSendPerson(announcementReceive.getRecorder());
			category.setReceivePerson(announcementReceive.getReceivePerson().getResume().getName());
			category.setContent(announcementReceive.getContent());
			category.setState(0);
			if (announcementReceive.getAttach()!=null) {
				category.setAttach(announcementReceive.getAttach());
			}
		}
		
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息在已收信息中就看不到了
		this.announcementCollectService.remove(this.announcementCollect);
		return SUCCESS;
	}
	@Action(value = "saveCategoryNotice", results = {
			@Result(name = "success", type = "redirect", location = "listNoticeOA"),
			@Result(name = "error", type = "chain", location = "listNoticeOA")})
	public String saveCategoryNotice() {
		if(this.noticeIds!=null){
			this.notice=this.noticeService.get(noticeIds[0]);
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(notice.getTitle());
		category.setDegree(notice.getDegree());
		category.setSendTime(notice.getRecordTime());
		category.setSendPerson(notice.getRecorder());
		category.setReceivePerson(notice.getReceive());
		category.setContent(notice.getContent());
		category.setState(0);
		if (notice.getAttach()!=null) {
			category.setAttach(notice.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息看不到了
		notice.setOabox(2);
		this.noticeService.submit(notice);
		return SUCCESS;
	}
	@Action(value = "saveCategoryNotice2", results = {
			@Result(name = "success", type = "redirect", location = "listNoticeReceiveOA"),
			@Result(name = "error", type = "chain", location = "viewNoticeReceive?noticeAccept=${noticeAccept.getId()}")})
	public String saveCategoryNotice2() {
		
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(noticeAccept.getTitle());
		category.setDegree(noticeAccept.getDegree());
		category.setSendTime(noticeAccept.getRecordTime());
		category.setSendPerson(noticeAccept.getRecorder());
		category.setReceivePerson(noticeAccept.getReceivePerson().getResume().getName());
		category.setContent(noticeAccept.getContent());
		category.setState(0);
		if (noticeAccept.getAttach()!=null) {
			category.setAttach(noticeAccept.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息看不到了
		noticeAccept.setOabox(2);
		this.noticeAcceptService.submit(noticeAccept);
		return SUCCESS;
	}
	@Action(value = "saveCategoryNoticeReceive", results = {
			@Result(name = "success", type = "redirect", location = "listNoticeReceiveOA"),
			@Result(name = "error", type = "chain", location = "listNoticeReceiveOA")})
	public String saveCategoryNoticeReceive() {
		if(this.receiveIds!=null){
			this.noticeAccept=this.noticeAcceptService.get(receiveIds[0]);
//			this.notice=this.noticeAccept.getNotice();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		category.setArchivesName(noticeAccept.getTitle());
		category.setDegree(noticeAccept.getDegree());
		category.setSendTime(noticeAccept.getRecordTime());
		category.setSendPerson(noticeAccept.getRecorder());
		category.setReceivePerson(noticeAccept.getReceivePerson().getResume().getName());
		category.setContent(noticeAccept.getContent());
		category.setState(0);
		if (noticeAccept.getAttach()!=null) {
			category.setAttach(noticeAccept.getAttach());
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息看不到了
		noticeAccept.setOabox(2);
		this.noticeAcceptService.submit(this.noticeAccept);
		return SUCCESS;
	}
	@Action(value = "saveCategoryNoticeCollect", results = {
			@Result(name = "success", type = "redirect", location = "listNoticeCollectOA"),
			@Result(name = "error", type = "chain", location = "listNoticeCollectOA")})
	public String saveCategoryNoticeCollect() {
		if(this.collectIds!=null){
			this.noticeCollect=this.noticeCollectService.get(collectIds[0]);
			this.notice=this.noticeCollect.getNotice();
			this.noticeAccept=this.noticeCollect.getNoticeAccept();
		}
		this.archivesType=this.archivesTypeService.get(id); //档案类目
		//档案管理信息
		ArchivesManager category=new ArchivesManager();
		category.setArchivesType(archivesType);
		category.setNumber("MSG"+new Date().getTime()+"G");
		if (notice!=null) {
			category.setArchivesName(notice.getTitle());
			category.setDegree(notice.getDegree());
			category.setSendTime(notice.getRecordTime());
			category.setSendPerson(notice.getRecorder());
			category.setReceivePerson(notice.getReceive());
			category.setContent(notice.getContent());
			category.setState(0);
			if (notice.getAttach()!=null) {
				category.setAttach(notice.getAttach());
			}
		}
		if (noticeAccept!=null) {
			category.setArchivesName(noticeAccept.getTitle());
			category.setDegree(noticeAccept.getDegree());
			category.setSendTime(noticeAccept.getRecordTime());
			category.setSendPerson(noticeAccept.getRecorder());
			category.setReceivePerson(noticeAccept.getReceivePerson().getResume().getName());
			category.setContent(noticeAccept.getContent());
			category.setState(0);
			if (noticeAccept.getAttach()!=null) {
				category.setAttach(noticeAccept.getAttach());
			}
		}
		category.setMark(1);
		this.getArchivesManagerService().save(category);
		//归档的信息看不到了
		this.noticeCollectService.remove(this.noticeCollect);
		return SUCCESS;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}
	public Integer[] getNewsIds() {
		return newsIds;
	}

	public void setNewsIds(Integer[] newsIds) {
		this.newsIds = newsIds;
	}

	public News getNews() {
		return news;
	}

	public void setNews(News news) {
		this.news = news;
	}

	public NewsService getNewsService() {
		return newsService;
	}

	public void setNewsService(NewsService newsService) {
		this.newsService = newsService;
	}

	public Integer[] getReceiveIds() {
		return receiveIds;
	}

	public void setReceiveIds(Integer[] receiveIds) {
		this.receiveIds = receiveIds;
	}

	public NewsReceive getNewsReceive() {
		return newsReceive;
	}

	public void setNewsReceive(NewsReceive newsReceive) {
		this.newsReceive = newsReceive;
	}

	public NewsReceiveService getNewsReceiveService() {
		return newsReceiveService;
	}

	public void setNewsReceiveService(NewsReceiveService newsReceiveService) {
		this.newsReceiveService = newsReceiveService;
	}
	public Integer[] getCollectIds() {
		return collectIds;
	}
	public void setCollectIds(Integer[] collectIds) {
		this.collectIds = collectIds;
	}
	public NewsCollect getNewsCollect() {
		return newsCollect;
	}
	public void setNewsCollect(NewsCollect newsCollect) {
		this.newsCollect = newsCollect;
	}
	public NewsCollectService getNewsCollectService() {
		return newsCollectService;
	}
	public void setNewsCollectService(NewsCollectService newsCollectService) {
		this.newsCollectService = newsCollectService;
	}
	public PictureNews getPictureNews() {
		return pictureNews;
	}
	public void setPictureNews(PictureNews pictureNews) {
		this.pictureNews = pictureNews;
	}
	public PictureNewsService getPictureNewsService() {
		return pictureNewsService;
	}
	public void setPictureNewsService(PictureNewsService pictureNewsService) {
		this.pictureNewsService = pictureNewsService;
	}
	public Integer[] getPictureIds() {
		return pictureIds;
	}
	public void setPictureIds(Integer[] pictureIds) {
		this.pictureIds = pictureIds;
	}
	public PictureNewsCollect getPictureNewsCollect() {
		return pictureNewsCollect;
	}
	public void setPictureNewsCollect(PictureNewsCollect pictureNewsCollect) {
		this.pictureNewsCollect = pictureNewsCollect;
	}
	public PictureNewsCollectService getPictureNewsCollectService() {
		return pictureNewsCollectService;
	}
	public void setPictureNewsCollectService(
			PictureNewsCollectService pictureNewsCollectService) {
		this.pictureNewsCollectService = pictureNewsCollectService;
	}
	public Announcement getAnnouncement() {
		return announcement;
	}
	public void setAnnouncement(Announcement announcement) {
		this.announcement = announcement;
	}
	public AnnouncementService getAnnouncementService() {
		return announcementService;
	}
	public void setAnnouncementService(AnnouncementService announcementService) {
		this.announcementService = announcementService;
	}
	public Integer[] getAnnouncementIds() {
		return announcementIds;
	}
	public void setAnnouncementIds(Integer[] announcementIds) {
		this.announcementIds = announcementIds;
	}
	public AnnouncementReceive getAnnouncementReceive() {
		return announcementReceive;
	}
	public void setAnnouncementReceive(AnnouncementReceive announcementReceive) {
		this.announcementReceive = announcementReceive;
	}
	public AnnouncementReceiveService getAnnouncementReceiveService() {
		return announcementReceiveService;
	}
	public void setAnnouncementReceiveService(
			AnnouncementReceiveService announcementReceiveService) {
		this.announcementReceiveService = announcementReceiveService;
	}
	public AnnouncementCollect getAnnouncementCollect() {
		return announcementCollect;
	}
	public void setAnnouncementCollect(AnnouncementCollect announcementCollect) {
		this.announcementCollect = announcementCollect;
	}
	public AnnouncementCollectService getAnnouncementCollectService() {
		return announcementCollectService;
	}
	public void setAnnouncementCollectService(
			AnnouncementCollectService announcementCollectService) {
		this.announcementCollectService = announcementCollectService;
	}
	public Notice getNotice() {
		return notice;
	}
	public void setNotice(Notice notice) {
		this.notice = notice;
	}
	public NoticeService getNoticeService() {
		return noticeService;
	}
	public void setNoticeService(NoticeService noticeService) {
		this.noticeService = noticeService;
	}
	public Integer[] getNoticeIds() {
		return noticeIds;
	}
	public void setNoticeIds(Integer[] noticeIds) {
		this.noticeIds = noticeIds;
	}
	public NoticeAccept getNoticeAccept() {
		return noticeAccept;
	}
	public void setNoticeAccept(NoticeAccept noticeAccept) {
		this.noticeAccept = noticeAccept;
	}
	public NoticeAcceptService getNoticeAcceptService() {
		return noticeAcceptService;
	}
	public void setNoticeAcceptService(NoticeAcceptService noticeAcceptService) {
		this.noticeAcceptService = noticeAcceptService;
	}
	public NoticeCollect getNoticeCollect() {
		return noticeCollect;
	}
	public void setNoticeCollect(NoticeCollect noticeCollect) {
		this.noticeCollect = noticeCollect;
	}
	public NoticeCollectService getNoticeCollectService() {
		return noticeCollectService;
	}
	public void setNoticeCollectService(NoticeCollectService noticeCollectService) {
		this.noticeCollectService = noticeCollectService;
	}
	public ArchivesManager getArchivesManager() {
		return archivesManager;
	}
	public void setArchivesManager(ArchivesManager archivesManager) {
		this.archivesManager = archivesManager;
	}
	public ArchivesManagerService getArchivesManagerService() {
		return archivesManagerService;
	}
	public void setArchivesManagerService(
			ArchivesManagerService archivesManagerService) {
		this.archivesManagerService = archivesManagerService;
	}
	public ArchivesType getArchivesType() {
		return archivesType;
	}
	public void setArchivesType(ArchivesType archivesType) {
		this.archivesType = archivesType;
	}
	public ArchivesTypeService getArchivesTypeService() {
		return archivesTypeService;
	}
	public void setArchivesTypeService(ArchivesTypeService archivesTypeService) {
		this.archivesTypeService = archivesTypeService;
	}
	public PictureNewsReceive getPictureNewsReceive() {
		return pictureNewsReceive;
	}
	public void setPictureNewsReceive(PictureNewsReceive pictureNewsReceive) {
		this.pictureNewsReceive = pictureNewsReceive;
	}
	public PictureNewsReceiveService getPictureNewsReceiveService() {
		return pictureNewsReceiveService;
	}
	public void setPictureNewsReceiveService(
			PictureNewsReceiveService pictureNewsReceiveService) {
		this.pictureNewsReceiveService = pictureNewsReceiveService;
	}
	
}
